home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 22 / Cream of the Crop 22.iso / program / recio215.zip / RECIO.C < prev    next >
C/C++ Source or Header  |  1996-10-26  |  15KB  |  409 lines
  1. /*****************************************************************************
  2.    MODULE: recio.c
  3.   PURPOSE: record input/output functions
  4. COPYRIGHT: (C) 1994-1996, William Pierpoint
  5.  COMPILER: Borland C Version 3.1
  6.        OS: MSDOS Version 6.2
  7.   VERSION: 2.15
  8.   RELEASE: October 26, 1996
  9. *****************************************************************************/
  10.  
  11. #include <ctype.h>
  12. #include <errno.h>
  13. #include <float.h>
  14. #include <limits.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. #include "recio.h"
  20.  
  21. #define rcol(rp)         ((rp)->r_colno)
  22. #define rflags(rp)       ((rp)->r_flags)
  23. #define rfd(rp)          ((rp)->r_fd)
  24. #define rfp(rp)          ((rp)->r_fp)
  25. #define rreclen(rp)      ((rp)->r_reclen)
  26. #define rrecsiz(rp)      ((rp)->r_recsiz)
  27. #define rfldsiz(rp)      ((rp)->r_fldsiz)
  28. #define rfldch(rp)       ((rp)->r_fldch)
  29. #define rtxtch(rp)       ((rp)->r_txtch)
  30. #define rtmfmt(rp)       ((rp)->r_tmfmt)
  31.  
  32. /* private module variables */
  33. static REC *_RECS = NULL;              /* ptr to array of RECs */
  34. static char _tmfmt[] = "%m/%d/%y";     /* default time format string */
  35.  
  36. static REC rin  = { 1,      0,    stdin,  "stdin",     0L,
  37.                     0,      0,        0,        0,   NULL, 
  38.                     0,   NULL, RECFLDCH, RECTXTCH,  _tmfmt, RECIN };
  39.  
  40. static REC rout = { 2, _R_WRT,   stdout, "stdout",     0L, 
  41.                     0,      0,        0,        0,   NULL, 
  42.                     0,   NULL, RECFLDCH, RECTXTCH, _tmfmt, RECOUT };
  43.  
  44. static REC rerr = { 3, _R_WRT,   stderr, "stderr",     0L, 
  45.                     0,      0,        0,        0,   NULL, 
  46.                     0,   NULL, RECFLDCH, RECTXTCH, _tmfmt, RECERR };
  47.  
  48. #if (R_NREC >= 4)
  49. static REC rprn = { 4, _R_WRT,   stdprn, "stdprn",     0L, 
  50.                     0,      0,        0,        0,   NULL, 
  51.                     0,   NULL, RECFLDCH, RECTXTCH, _tmfmt, RECPRN };
  52. #endif
  53.  
  54. #define ROPEN_MIN R_NREC       /* reserved for recin, etc */
  55. #define ROPEN     max(ROPEN_MAX, ROPEN_MIN)
  56.  
  57. /* public variables */
  58. REC *recin = &rin;
  59. REC *recout = &rout;
  60. REC *recerr = &rerr;
  61. #if (R_NREC >= 4)
  62. REC *recprn = &rprn;
  63. #endif
  64.  
  65. /* friend variables */
  66. char _r_nsbuf[NSBUFSIZ];     /* buffer for numeric to string conversions */
  67. void (*_r_errfn)(REC *);     /* pointer to error message function */
  68.  
  69. /* Support functions */
  70. /****************************************************************************/
  71. static void                  /* returns nothing                             */
  72.     _rexit(                  /* at program exit, clean up                   */
  73.         void)                /* no arguments                                */
  74. /****************************************************************************/
  75. {
  76.     /* free recin buffers */
  77.     free(rflds(recin));
  78.     free(rrecs(recin));
  79.     rflds(recin) = NULL;
  80.     rfldsiz(recin) = 0;
  81.     rrecs(recin) = NULL;
  82.     rrecsiz(recin) = 0;
  83.     rreclen(recin) = 0;
  84.  
  85.     /* ensure all record streams closed */
  86.     rcloseall();
  87. }
  88.  
  89. /****************************************************************************/
  90. void                         /* return error number (0=no error)            */
  91.     _rsetexitfn(             /* register _rexit function with atexit()      */
  92.         REC *rp)             /* record pointer                              */
  93. /****************************************************************************/
  94. {
  95.     static int once=0;       /* register exit fn only once */
  96.  
  97.     if (!once) {
  98.  
  99.         /* execute this path at most one time */
  100.         once++;
  101.  
  102.         /* if atexit() fails to register _rexit() function */
  103.         if (atexit(_rexit)) {
  104.  
  105.            /* register warning */
  106.            rsetwarn(rp, R_WNOREG);
  107.         }
  108.     }
  109. } 
  110.  
  111. /****************************************************************************/
  112. int                          /* return error number (0=no error)            */
  113.     _rmoderror(              /* check for mode error                        */
  114.         REC *rp,             /* record pointer                              */
  115.         int mode)            /* mode (0=read; !0=write/append)              */
  116. /****************************************************************************/
  117. {
  118.     int errnum=0;            /* error number (0=mode ok, !0=invalid mode) */
  119.     unsigned smode;          /* stream mode */
  120.  
  121.     /* if stream _R_WRT flag does not match mode */
  122.     smode = rflags(rp) & _R_WRT;
  123.     if ((mode && !smode) || (!mode && smode)) {
  124.         errnum = rseterr(rp, R_EINVMOD);
  125.     }
  126.     return errnum;
  127. }
  128.  
  129. /****************************************************************************/
  130. int                          /* return !0 if ready; 0 if in error state     */
  131.     _risready(               /* see if record stream is ready               */
  132.         REC *rp,             /* record pointer                              */
  133.         int mode)            /* mode (0=read; !0=write/append)              */
  134. /****************************************************************************/
  135. {
  136.     int errnum=0;            /* error number */
  137.  
  138.     /* test for valid record pointer */
  139.     if (!risvalid(rp)) {
  140.         errnum = rseterr(NULL, EINVAL);
  141.         goto done;
  142.     }
  143.     
  144.     /* check mode */
  145.     errnum = _rmoderror(rp, mode);
  146.     if (errnum) goto done;
  147.  
  148.     /* if record 0 and write mode, set record number to 1 */
  149.     if (!rrecno(rp) && mode) rrecno(rp)++;
  150.  
  151.     /* test for any previous error */
  152.     errnum = rerror(rp);
  153.  
  154. done:
  155.     return (!(errnum));
  156. }
  157.  
  158. /****************************************************************************/
  159. static void                  /* returns nothing                             */
  160.     _rfree(                  /* free the memory allocated to a record       */
  161.         REC *rp)             /* record pointer                              */
  162. /****************************************************************************/
  163. {
  164.     if (risvalid(rp)) {
  165.         free(rflds(rp));
  166.         free(rrecs(rp));
  167.         if (rfp(rp)) fclose(rfp(rp));
  168.         memset(rp, 0, sizeof(REC));
  169.     }
  170. }
  171.  
  172. /* User functions */
  173. /****************************************************************************/
  174. REC *                        /* return record pointer                       */
  175.     ropen(                   /* open a record stream for reading            */
  176.         const char *fname,   /* name of file to open                        */
  177.         const char *mode)    /* type of mode used to open file              */
  178. /****************************************************************************/
  179. {
  180.     REC *rp = _RECS;         /* record pointer */
  181.     int  i;                  /* count of REC structures */
  182.     int  ch;                 /* first character of mode */
  183.     
  184.     errno = 0;
  185.  
  186.     /* only modes currently supported are "r", "w", and "a" */
  187.     ch = tolower(*mode);
  188.     if (!(ch=='r' || ch=='w' || ch=='a')) {
  189.         rp = NULL;
  190.         rseterr(NULL, EINVAL);
  191.         goto done;
  192.     }
  193.  
  194.     /* allocate memory for array of REC structures */
  195.     if (!rp) {
  196.         do {
  197.             /* note: no memory allocation needed for recin, etc */
  198.             rp = _RECS = (REC *) calloc(ROPEN-R_NREC, sizeof(REC));
  199.             if (!rp) {
  200.                 if (rseterr(NULL, ENOMEM)) goto done;
  201.             }
  202.         } while (!rp);
  203.     }
  204.  
  205.     /* search thru REC structures until empty position found */
  206.     for (i=R_NREC+1; i <= ROPEN; i++, rp++) {
  207.         if (!rfd(rp)) {
  208.             rfd(rp) = i;
  209.             break;
  210.         }
  211.     }
  212.     /* error if out of positions */
  213.     if (i > ROPEN) {
  214.         rp = NULL;
  215.         rseterr(NULL, EMFILE);
  216.         goto done;
  217.     }
  218.  
  219.     /* open file */
  220.     rfp(rp) = fopen(fname, mode);
  221.     if (!rfp(rp)) {
  222.         rclose(rp);
  223.         rp = NULL;
  224.         /* if error other than path/file not found */
  225.         if (errno != ENOENT) {
  226.             rseterr(NULL, errno);
  227.         }
  228.         goto done;
  229.     }
  230.  
  231.     /* initialize */
  232.     rflags(rp)  = 0;
  233.     if (ch != 'r') rflags(rp) |= _R_WRT;
  234.     rnames(rp)  = fname;
  235.     rrecno(rp)  = 0L;
  236.     rfldno(rp)  = 0;
  237.     rcol(rp)    = 0;
  238.     rrecsiz(rp) = 0;
  239.     rreclen(rp) = 0;
  240.     rrecs(rp)   = NULL;
  241.     rfldsiz(rp) = 0;
  242.     rflds(rp)   = NULL;
  243.     rfldch(rp)  = RECFLDCH;
  244.     rtxtch(rp)  = RECTXTCH;
  245.     rtmfmt(rp) = _tmfmt;
  246.     rcxtno(rp) = 0;
  247.     _rsetexitfn(rp);
  248.  
  249. done:
  250.     return rp;
  251. }
  252.  
  253. /****************************************************************************/
  254. void                         /* returns nothing                             */
  255.     rclose(                  /* close a record stream                       */
  256.         REC *rp)             /* record pointer                              */
  257. /****************************************************************************/
  258. {
  259.     int i;                   /* count REC structures */
  260.     REC *recp=_RECS;         /* pointer to _RECS array */
  261.  
  262.     if (risvalid(rp)) {
  263.         /* close record stream, but not recin, recout, recerr */
  264.         if (rfd(rp) > R_NREC) _rfree(rp);
  265.  
  266.         /* if all record streams closed, free _RECS */
  267.         /* note: valid rp implies valid recp */
  268.         for (i=R_NREC+1; i <= ROPEN; i++, recp++) {
  269.             if (rfd(recp)) goto done;
  270.         }
  271.         free(_RECS);
  272.         _RECS = NULL;
  273.  
  274.     } else {
  275.         rseterr(NULL, EINVAL);
  276.     }
  277.  
  278. done:
  279.     return;
  280. }
  281.  
  282. /****************************************************************************/
  283. int                          /* returns number of streams closed            */
  284.     rcloseall(               /* close all record streams                    */
  285.         void)                /* no arguments                                */
  286. /****************************************************************************/
  287. {
  288.     int num=0;               /* number of streams closed */
  289.     int i;                   /* count REC structures */
  290.     REC *recp=_RECS;         /* pointer to _RECS array */
  291.  
  292.     /* close every open record stream, except recin, etc */
  293.     if (recp) {
  294.         for (i=R_NREC+1; i <= ROPEN; i++, recp++) {
  295.             if (rfd(recp)) {
  296.                 _rfree(recp);
  297.                 num++;
  298.             }
  299.         }
  300.         free(_RECS);
  301.         _RECS = NULL;
  302.     }
  303.     return num;
  304. }
  305.  
  306. /****************************************************************************/
  307. int                          /* return !0 for valid; 0 for invalid          */
  308.     risvalid(                /* is record pointer valid?                    */
  309.         REC *rp)             /* record pointer                              */
  310. /****************************************************************************/
  311. {
  312.     int valid=1;             /* validation state (!0=valid) */
  313.  
  314.     /* if rp is null pointer or rfd not between 1 and ROPEN */
  315.     if (!rp || rfd(rp) < 1 || rfd(rp) > ROPEN) {
  316.         /* invalid record pointer */
  317.         valid = 0;
  318.     }
  319.     return valid;
  320. }
  321.  
  322. /****************************************************************************/
  323. void                         /* returns nothing                             */
  324.     rsetfldch(               /* set field separator character               */
  325.         REC *rp,             /* record pointer                              */
  326.         int  ch)             /* field separator character                   */
  327. /****************************************************************************/
  328. {
  329.     if (risvalid(rp)) {
  330.         if (isascii(ch)) {
  331.             rfldch(rp) = ch;
  332.         } else {
  333.             rseterr(rp, R_EINVAL);
  334.         }
  335.     } else {
  336.         rseterr(NULL, EINVAL);
  337.     }
  338. }
  339.  
  340. /****************************************************************************/
  341. void                         /* returns nothing                             */
  342.     rsettxtch(               /* set text string delimiter character         */
  343.         REC *rp,             /* record pointer                              */
  344.         int  ch)             /* text delimiter character                    */
  345. /****************************************************************************/
  346. {
  347.     if (risvalid(rp)) {
  348.         if (isascii(ch)) {
  349.             rtxtch(rp) = ch;
  350.         } else {
  351.             rseterr(rp, R_EINVAL);
  352.         }
  353.     } else {
  354.         rseterr(NULL, EINVAL);
  355.     }
  356. }
  357.  
  358. /****************************************************************************/
  359. void                         /* returns nothing                             */
  360.     rsettmfmt(               /* set time format string for record stream    */
  361.         REC *rp,             /* record pointer                              */
  362.         const char *fmt)     /* time format string                          */
  363. /****************************************************************************/
  364. {
  365.     if (risvalid(rp)) {
  366.         rtmfmt(rp) = fmt;
  367.     } else {
  368.         rseterr(NULL, EINVAL);
  369.     }
  370. }
  371.  
  372. /****************************************************************************/
  373. void                         /* returns nothing                             */
  374.     rsetcxtno(               /* set context number of record stream         */
  375.         REC *rp,             /* record pointer                              */
  376.         int  cxtno)          /* context number                              */
  377. /****************************************************************************/
  378. {
  379.     if (risvalid(rp)) {
  380.         if (rcxtno(rp) >= 0  && cxtno >= 0) {
  381.             rcxtno(rp) = cxtno;
  382.         } else {
  383.             rseterr(rp, R_EINVAL);
  384.         }
  385.     } else {
  386.         rseterr(NULL, EINVAL);
  387.     }
  388. }
  389.  
  390. /****************************************************************************/
  391. void                         /* returns nothing                             */
  392.     rsetbegcolno(            /* set beginning record column number          */
  393.         REC *rp,             /* record pointer                              */
  394.         int  colno)          /* first column in record is 0 or 1            */
  395. /****************************************************************************/
  396. {
  397.     if (risvalid(rp)) {
  398.         if (colno == 1) {
  399.             rflags(rp) |= _R_COL;
  400.         } else if (colno == 0) {
  401.             rflags(rp) &= ~_R_COL;
  402.         } else {
  403.             rseterr(rp, R_EINVAL);
  404.         }
  405.     } else {
  406.         rseterr(NULL, EINVAL);
  407.     }
  408. }
  409.